package main

import (
	"fmt"
	"log"
	"time"

	modbus "gitee.com/barryzxy/gomodbus"
)

// 基础TCP客户端示例 - 展示优化后的向后兼容性
// 这个示例使用现有的API，但自动获得了内部优化的好处：
// - 增强的并发安全性
// - 改进的错误处理
// - 自动内存管理
// - 更好的性能和稳定性

func main() {
	fmt.Println("=== Modbus 基础TCP客户端示例（优化版本）===")
	fmt.Println("注意：此示例使用完全相同的API，但获得了内部优化的所有好处")

	// 1. 创建客户端（API完全不变，但内部已经优化）
	provider := modbus.NewTCPClientProvider("localhost:502", modbus.WithEnableLogger())
	client := modbus.NewClient(provider)

	// 显示优化状态（新增功能，但不影响向后兼容性）
	fmt.Println("\n📊 内部优化状态：")
	fmt.Println("✅ 并发安全性增强")
	fmt.Println("✅ 错误处理改进")
	fmt.Println("✅ 内存管理优化")
	fmt.Println("✅ 自动资源清理")

	// 2. 连接到服务器（API不变，但错误信息更详细）
	fmt.Println("\n🔌 连接到Modbus服务器...")
	err := client.Connect()
	if err != nil {
		// 现在获得更详细的错误信息，但错误类型保持兼容
		log.Printf("连接失败: %v", err)

		// 演示：自动重试功能可以通过选项启用（向后兼容）
		fmt.Println("\n💡 提示：可以启用自动重试功能获得更好的连接稳定性")
		fmt.Println("   使用：modbus.WithAutoRetry(true)")
		return
	}
	defer client.Close()

	fmt.Println("✅ 连接成功！")

	// 3. 基本读取操作（API完全不变，但并发安全性增强）
	fmt.Println("\n📖 执行基本读取操作...")

	// 读取线圈（现在是完全并发安全的）
	fmt.Print("读取线圈 (地址 0-9): ")
	coils, err := client.ReadCoils(1, 0, 10)
	if err != nil {
		// 增强的错误信息，包含更多上下文
		fmt.Printf("失败 - %v\n", err)
	} else {
		fmt.Printf("成功 - 数据: %v\n", coils)
	}

	// 读取保持寄存器（现在有更好的内存管理）
	fmt.Print("读取保持寄存器 (地址 0-4): ")
	registers, err := client.ReadHoldingRegisters(1, 0, 5)
	if err != nil {
		fmt.Printf("失败 - %v\n", err)
	} else {
		fmt.Printf("成功 - 数据: %v\n", registers)
	}

	// 4. 基本写入操作（API不变，但原子性增强）
	fmt.Println("\n✏️  执行基本写入操作...")

	// 写入单个线圈
	fmt.Print("写入单个线圈 (地址 0, 值 true): ")
	err = client.WriteSingleCoil(1, 0, true)
	if err != nil {
		fmt.Printf("失败 - %v\n", err)
	} else {
		fmt.Println("成功")
	}

	// 写入单个寄存器
	fmt.Print("写入单个寄存器 (地址 0, 值 12345): ")
	err = client.WriteSingleRegister(1, 0, 12345)
	if err != nil {
		fmt.Printf("失败 - %v\n", err)
	} else {
		fmt.Println("成功")
	}

	// 5. 批量操作（现在有更好的性能和稳定性）
	fmt.Println("\n📦 执行批量操作...")

	// 写入多个寄存器
	values := []uint16{100, 200, 300, 400, 500}
	fmt.Printf("写入多个寄存器 (地址 10-14, 值 %v): ", values)
	err = client.WriteMultipleRegisters(1, 10, uint16(len(values)), values)
	if err != nil {
		fmt.Printf("失败 - %v\n", err)
	} else {
		fmt.Println("成功")

		// 验证写入
		fmt.Print("验证写入的数据: ")
		readBack, err := client.ReadHoldingRegisters(1, 10, uint16(len(values)))
		if err != nil {
			fmt.Printf("验证失败 - %v\n", err)
		} else {
			fmt.Printf("成功 - 读回数据: %v\n", readBack)
		}
	}

	// 6. 连续操作测试（展示改进的并发安全性和性能）
	fmt.Println("\n🔄 执行连续操作测试（展示优化后的性能）...")

	start := time.Now()
	operationCount := 50
	successCount := 0

	for i := 0; i < operationCount; i++ {
		// 读取操作（现在是完全线程安全的）
		_, err := client.ReadHoldingRegisters(1, uint16(i%10), 1)
		if err == nil {
			successCount++
		}

		// 小延迟避免过快请求
		time.Sleep(10 * time.Millisecond)
	}

	duration := time.Since(start)
	successRate := float64(successCount) / float64(operationCount) * 100

	fmt.Printf("完成 %d 次操作，耗时 %v\n", operationCount, duration)
	fmt.Printf("成功率: %.1f%% (%d/%d)\n", successRate, successCount, operationCount)
	fmt.Printf("平均每次操作: %v\n", duration/time.Duration(operationCount))

	// 7. 优化效果说明
	fmt.Println("\n🎯 优化效果总结：")
	fmt.Println("✨ 向后兼容性: 100% - 无需修改任何现有代码")
	fmt.Println("🚀 性能提升: 内存使用优化，GC压力减少")
	fmt.Println("🛡️  稳定性增强: 并发安全，错误恢复能力提升")
	fmt.Println("📊 监控改进: 更详细的错误信息和诊断数据")
	fmt.Println("🔧 内存管理: 自动资源清理，防止内存泄漏")

	fmt.Println("\n💡 提示：要启用更多高级功能，请参考增强功能示例")
	fmt.Println("   例如：自动重试、性能监控、资源统计等")
}
